M

MLOG

Slovenčina

Odomknite silu GraphQL federácie pomocou Schema Stitching. Naučte sa, ako vytvoriť zjednotené GraphQL API z viacerých služieb, čím zlepšíte škálovateľnosť a udržiavateľnosť.

GraphQL federácia: Schema Stitching - Komplexný sprievodca

V neustále sa vyvíjajúcom prostredí moderného vývoja aplikácií sa stala prvoradou potreba škálovateľných a udržiavateľných architektúr. Mikroslužby, s ich vrodenou modularitou a nezávislou nasaditeľnosťou, sa stali populárnym riešením. Správa mnohých mikroslužieb však môže priniesť komplikácie, najmä pokiaľ ide o poskytovanie zjednoteného API pre klientske aplikácie. Práve tu prichádza na scénu GraphQL federácia, a konkrétne Schema Stitching.

Čo je GraphQL federácia?

GraphQL federácia je výkonná architektúra, ktorá vám umožňuje vytvoriť jedno, zjednotené GraphQL API z viacerých podkladových GraphQL služieb (často reprezentujúcich mikroslužby). Umožňuje vývojárom dopytovať dáta naprieč rôznymi službami, akoby išlo o jeden graf, čím sa zjednodušuje klientska skúsenosť a znižuje sa potreba zložitej orchestrácie na strane klienta.

Existujú dva hlavné prístupy k GraphQL federácii:

Tento článok sa zameriava na Schema Stitching, skúma jeho koncepty, výhody, obmedzenia a praktickú implementáciu.

Pochopenie Schema Stitching

Schema Stitching je proces spájania viacerých GraphQL schém do jednej, súdržnej schémy. Táto zjednotená schéma funguje ako fasáda, ktorá pred klientom skrýva zložitosť podkladových služieb. Keď klient pošle požiadavku na spojenú schému, brána inteligentne presmeruje požiadavku na príslušnú podkladovú službu (alebo služby), získa dáta a skombinuje výsledky pred ich vrátením klientovi.

Predstavte si to takto: Máte viacero reštaurácií (služieb), z ktorých každá sa špecializuje na inú kuchyňu. Schema Stitching je ako univerzálne menu, ktoré kombinuje všetky jedlá z každej reštaurácie. Keď si zákazník (klient) objedná z univerzálneho menu, objednávka je inteligentne presmerovaná do príslušných kuchýň reštaurácií, jedlo sa pripraví a potom sa skombinuje do jednej dodávky pre zákazníka.

Kľúčové koncepty v Schema Stitching

Výhody Schema Stitching

Schema Stitching ponúka niekoľko presvedčivých výhod pre organizácie, ktoré prijímajú architektúru mikroslužieb:

Obmedzenia Schema Stitching

Hoci Schema Stitching ponúka početné výhody, je dôležité si uvedomiť aj jeho obmedzenia:

Praktická implementácia Schema Stitching

Prejdime si zjednodušený príklad, ako implementovať Schema Stitching pomocou Node.js a knižnice graphql-tools (populárna voľba pre spájanie schém). Tento príklad zahŕňa dve mikroslužby: službu pre používateľov (User Service) a službu pre produkty (Product Service).

1. Definujte vzdialené schémy

Najprv definujte GraphQL schémy pre každú zo vzdialených služieb.

Služba pre používateľov (user-service.js):


const { buildSchema } = require('graphql');

const userSchema = buildSchema(`
  type User {
    id: ID!
    name: String
    email: String
  }

  type Query {
    user(id: ID!): User
  }
`);

const users = [
  { id: '1', name: 'Alice Smith', email: 'alice@example.com' },
  { id: '2', name: 'Bob Johnson', email: 'bob@example.com' },
];

const userRoot = {
  user: (args) => users.find(user => user.id === args.id),
};

module.exports = {
  schema: userSchema,
  rootValue: userRoot,
};

Služba pre produkty (product-service.js):


const { buildSchema } = require('graphql');

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Cudzí kľúč k User Service
  }

  type Query {
    product(id: ID!): Product
  }
`);

const products = [
  { id: '101', name: 'Laptop', price: 1200, userId: '1' },
  { id: '102', name: 'Smartphone', price: 800, userId: '2' },
];

const productRoot = {
  product: (args) => products.find(product => product.id === args.id),
};

module.exports = {
  schema: productSchema,
  rootValue: productRoot,
};

2. Vytvorte službu brány (Gateway)

Teraz vytvorte službu brány, ktorá spojí obe schémy dohromady.

Služba brány (gateway.js):


const { stitchSchemas } = require('@graphql-tools/stitch');
const { makeRemoteExecutableSchema } = require('@graphql-tools/wrap');
const { graphqlHTTP } = require('express-graphql');
const express = require('express');
const { introspectSchema } = require('@graphql-tools/wrap');
const { printSchema } = require('graphql');
const fetch = require('node-fetch');

async function createRemoteSchema(uri) {
  const fetcher = async (params) => {
    const response = await fetch(uri, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(params),
    });
    return response.json();
  };

  const schema = await introspectSchema(fetcher);
  return makeRemoteExecutableSchema({
    schema,
    fetcher,
  });
}

async function main() {
  const userSchema = await createRemoteSchema('http://localhost:4001/graphql');
  const productSchema = await createRemoteSchema('http://localhost:4002/graphql');

  const stitchedSchema = stitchSchemas({
    subschemas: [
      { schema: userSchema },
      { schema: productSchema },
    ],
    typeDefs: `
      extend type Product {
        user: User
      }
    `,
    resolvers: {
      Product: {
        user: {
          selectionSet: `{ userId }`,
          resolve(product, args, context, info) {
            return info.mergeInfo.delegateToSchema({
              schema: userSchema,
              operation: 'query',
              fieldName: 'user',
              args: {
                id: product.userId,
              },
              context,
              info,
            });
          },
        },
      },
    },
  });

  const app = express();
  app.use('/graphql', graphqlHTTP({
    schema: stitchedSchema,
    graphiql: true,
  }));

  app.listen(4000, () => console.log('Server brány beží na http://localhost:4000/graphql'));
}

main().catch(console.error);

3. Spustite služby

Budete musieť spustiť službu pre používateľov a službu pre produkty na rôznych portoch. Napríklad:

Služba pre používateľov (port 4001):


const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./user-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4001, () => console.log('Služba pre používateľov beží na http://localhost:4001/graphql'));

Služba pre produkty (port 4002):


const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./product-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4002, () => console.log('Služba pre produkty beží na http://localhost:4002/graphql'));

4. Dopytujte spojenú schému

Teraz môžete dopytovať spojenú schému cez bránu (bežiacu na porte 4000). Môžete spustiť dopyt ako tento:


query {
  product(id: "101") {
    id
    name
    price
    user {
      id
      name
      email
    }
  }
}

Tento dopyt získa produkt s ID "101" a tiež načíta priradeného používateľa zo služby pre používateľov, čo demonštruje, ako Schema Stitching umožňuje dopytovať dáta naprieč viacerými službami v jedinej požiadavke.

Pokročilé techniky Schema Stitching

Okrem základného príkladu, tu sú niektoré pokročilé techniky, ktoré možno použiť na vylepšenie vašej implementácie Schema Stitching:

Voľba medzi Schema Stitching a Apollo federáciou

Hoci je Schema Stitching životaschopnou možnosťou pre GraphQL federáciu, Apollo federácia sa stala populárnejšou voľbou vďaka svojim pokročilým funkciám a zlepšenej vývojárskej skúsenosti. Tu je porovnanie oboch prístupov:

Funkcia Schema Stitching Apollo federácia
Definícia schémy Používa existujúci jazyk GraphQL schém Používa deklaratívny jazyk schém s direktívami
Plánovanie dopytov Vyžaduje manuálne delegovanie dopytov Automatické plánovanie dopytov pomocou Apollo Gateway
Rozšírenia typov Obmedzená podpora Zabudovaná podpora pre rozšírenia typov
Kľúčové direktívy Nepodporované Používa direktívu @key na identifikáciu entít
Distribuované sledovanie Vyžaduje manuálnu implementáciu Zabudovaná podpora pre distribuované sledovanie
Nástroje a ekosystém Menej zrelé nástroje Zrelšie nástroje a veľká komunita
Zložitosť Môže byť zložité na správu vo veľkých systémoch Navrhnuté pre veľké a zložité systémy

Kedy zvoliť Schema Stitching:

Kedy zvoliť Apollo federáciu:

Príklady z reálneho sveta a prípady použitia

Tu sú niektoré príklady z reálneho sveta, ako sa dá GraphQL federácia, vrátane Schema Stitching, použiť:

Osvedčené postupy pre Schema Stitching

Aby ste zaistili úspešnú implementáciu Schema Stitching, dodržiavajte tieto osvedčené postupy:

Záver

GraphQL federácia so Schema Stitching ponúka výkonný prístup k budovaniu zjednotených API z viacerých služieb v architektúre mikroslužieb. Porozumením jej základných konceptov, výhod, obmedzení a implementačných techník môžete využiť Schema Stitching na zjednodušenie prístupu k dátam, zlepšenie škálovateľnosti a zvýšenie udržiavateľnosti. Hoci sa Apollo federácia stala pokročilejším riešením, Schema Stitching zostáva životaschopnou možnosťou pre jednoduchšie scenáre alebo pri integrácii existujúcich GraphQL služieb. Starostlivo zvážte svoje špecifické potreby a požiadavky, aby ste si vybrali najlepší prístup pre vašu organizáciu.